home *** CD-ROM | disk | FTP | other *** search
/ Power Programmierung / Power-Programmierung CD 2 (Tewi)(1994).iso / c / compcomp / byacc / error_ta.c < prev    next >
C/C++ Source or Header  |  1991-01-08  |  7KB  |  272 lines
  1. #ifndef lint
  2. static char yysccsid[] = "@(#)yaccpar     1.7 (Berkeley) 09/09/90";
  3. #endif
  4. #define YYBYACC 1
  5. #define YYERRCODE 256
  6. short yylhs[] = {                                        -1,
  7.     0,
  8. };
  9. short yylen[] = {                                         2,
  10.     1,
  11. };
  12. short yydefred[] = {                                      0,
  13.     1,    0,
  14. };
  15. short yydgoto[] = {                                       2,
  16. };
  17. short yysindex[] = {                                   -256,
  18.     0,    0,
  19. };
  20. short yyrindex[] = {                                      0,
  21.     0,    0,
  22. };
  23. short yygindex[] = {                                      0,
  24. };
  25. #define YYTABLESIZE 0
  26. short yytable[] = {                                       1,
  27. };
  28. short yycheck[] = {                                     256,
  29. };
  30. #define YYFINAL 2
  31. #ifndef YYDEBUG
  32. #define YYDEBUG 0
  33. #endif
  34. #define YYMAXTOKEN 0
  35. #if YYDEBUG
  36. char *yyname[] = {
  37. "end-of-file",
  38. };
  39. char *yyrule[] = {
  40. "$accept : S",
  41. "S : error",
  42. };
  43. #endif
  44. #ifndef YYSTYPE
  45. typedef int YYSTYPE;
  46. #endif
  47. #define yyclearin (yychar=(-1))
  48. #define yyerrok (yyerrflag=0)
  49. #ifdef YYSTACKSIZE
  50. #ifndef YYMAXDEPTH
  51. #define YYMAXDEPTH YYSTACKSIZE
  52. #endif
  53. #else
  54. #ifdef YYMAXDEPTH
  55. #define YYSTACKSIZE YYMAXDEPTH
  56. #else
  57. #define YYSTACKSIZE 600
  58. #define YYMAXDEPTH 600
  59. #endif
  60. #endif
  61. int yydebug;
  62. int yynerrs;
  63. int yyerrflag;
  64. int yychar;
  65. short *yyssp;
  66. YYSTYPE *yyvsp;
  67. YYSTYPE yyval;
  68. YYSTYPE yylval;
  69. short yyss[YYSTACKSIZE];
  70. YYSTYPE yyvs[YYSTACKSIZE];
  71. #define yystacksize YYSTACKSIZE
  72. #line 4 "error.y"
  73. main(){printf("yyparse() = %d\n",yyparse());}
  74. yylex(){return-1;}
  75. yyerror(s)char*s;{printf("%s\n",s);}
  76. #line 77 "error_tab.c"
  77. #define YYABORT goto yyabort
  78. #define YYACCEPT goto yyaccept
  79. #define YYERROR goto yyerrlab
  80. int
  81. yyparse()
  82. {
  83.     register int yym, yyn, yystate;
  84. #if YYDEBUG
  85.     register char *yys;
  86.     extern char *getenv();
  87.  
  88.     if (yys = getenv("YYDEBUG"))
  89.     {
  90.         yyn = *yys;
  91.         if (yyn >= '0' && yyn <= '9')
  92.             yydebug = yyn - '0';
  93.     }
  94. #endif
  95.  
  96.     yynerrs = 0;
  97.     yyerrflag = 0;
  98.     yychar = (-1);
  99.  
  100.     yyssp = yyss;
  101.     yyvsp = yyvs;
  102.     *yyssp = yystate = 0;
  103.  
  104. yyloop:
  105.     if (yyn = yydefred[yystate]) goto yyreduce;
  106.     if (yychar < 0)
  107.     {
  108.         if ((yychar = yylex()) < 0) yychar = 0;
  109. #if YYDEBUG
  110.         if (yydebug)
  111.         {
  112.             yys = 0;
  113.             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  114.             if (!yys) yys = "illegal-symbol";
  115.             printf("yydebug: state %d, reading %d (%s)\n", yystate,
  116.                     yychar, yys);
  117.         }
  118. #endif
  119.     }
  120.     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
  121.             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
  122.     {
  123. #if YYDEBUG
  124.         if (yydebug)
  125.             printf("yydebug: state %d, shifting to state %d\n",
  126.                     yystate, yytable[yyn]);
  127. #endif
  128.         if (yyssp >= yyss + yystacksize - 1)
  129.         {
  130.             goto yyoverflow;
  131.         }
  132.         *++yyssp = yystate = yytable[yyn];
  133.         *++yyvsp = yylval;
  134.         yychar = (-1);
  135.         if (yyerrflag > 0)  --yyerrflag;
  136.         goto yyloop;
  137.     }
  138.     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
  139.             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
  140.     {
  141.         yyn = yytable[yyn];
  142.         goto yyreduce;
  143.     }
  144.     if (yyerrflag) goto yyinrecovery;
  145. #ifdef lint
  146.     goto yynewerror;
  147. #endif
  148. yynewerror:
  149.     yyerror("syntax error");
  150. #ifdef lint
  151.     goto yyerrlab;
  152. #endif
  153. yyerrlab:
  154.     ++yynerrs;
  155. yyinrecovery:
  156.     if (yyerrflag < 3)
  157.     {
  158.         yyerrflag = 3;
  159.         for (;;)
  160.         {
  161.             if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
  162.                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
  163.             {
  164. #if YYDEBUG
  165.                 if (yydebug)
  166.                     printf("yydebug: state %d, error recovery shifting\
  167.  to state %d\n", *yyssp, yytable[yyn]);
  168. #endif
  169.                 if (yyssp >= yyss + yystacksize - 1)
  170.                 {
  171.                     goto yyoverflow;
  172.                 }
  173.                 *++yyssp = yystate = yytable[yyn];
  174.                 *++yyvsp = yylval;
  175.                 goto yyloop;
  176.             }
  177.             else
  178.             {
  179. #if YYDEBUG
  180.                 if (yydebug)
  181.                     printf("yydebug: error recovery discarding state %d\n",
  182.                             *yyssp);
  183. #endif
  184.                 if (yyssp <= yyss) goto yyabort;
  185.                 --yyssp;
  186.                 --yyvsp;
  187.             }
  188.         }
  189.     }
  190.     else
  191.     {
  192.         if (yychar == 0) goto yyabort;
  193. #if YYDEBUG
  194.         if (yydebug)
  195.         {
  196.             yys = 0;
  197.             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  198.             if (!yys) yys = "illegal-symbol";
  199.             printf("yydebug: state %d, error recovery discards token %d (%s)\n",
  200.                     yystate, yychar, yys);
  201.         }
  202. #endif
  203.         yychar = (-1);
  204.         goto yyloop;
  205.     }
  206. yyreduce:
  207. #if YYDEBUG
  208.     if (yydebug)
  209.         printf("yydebug: state %d, reducing by rule %d (%s)\n",
  210.                 yystate, yyn, yyrule[yyn]);
  211. #endif
  212.     yym = yylen[yyn];
  213.     yyval = yyvsp[1-yym];
  214.     switch (yyn)
  215.     {
  216.     }
  217.     yyssp -= yym;
  218.     yystate = *yyssp;
  219.     yyvsp -= yym;
  220.     yym = yylhs[yyn];
  221.     if (yystate == 0 && yym == 0)
  222.     {
  223. #if YYDEBUG
  224.         if (yydebug)
  225.             printf("yydebug: after reduction, shifting from state 0 to\
  226.  state %d\n", YYFINAL);
  227. #endif
  228.         yystate = YYFINAL;
  229.         *++yyssp = YYFINAL;
  230.         *++yyvsp = yyval;
  231.         if (yychar < 0)
  232.         {
  233.             if ((yychar = yylex()) < 0) yychar = 0;
  234. #if YYDEBUG
  235.             if (yydebug)
  236.             {
  237.                 yys = 0;
  238.                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  239.                 if (!yys) yys = "illegal-symbol";
  240.                 printf("yydebug: state %d, reading %d (%s)\n",
  241.                         YYFINAL, yychar, yys);
  242.             }
  243. #endif
  244.         }
  245.         if (yychar == 0) goto yyaccept;
  246.         goto yyloop;
  247.     }
  248.     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
  249.             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
  250.         yystate = yytable[yyn];
  251.     else
  252.         yystate = yydgoto[yym];
  253. #if YYDEBUG
  254.     if (yydebug)
  255.         printf("yydebug: after reduction, shifting from state %d \
  256. to state %d\n", *yyssp, yystate);
  257. #endif
  258.     if (yyssp >= yyss + yystacksize - 1)
  259.     {
  260.         goto yyoverflow;
  261.     }
  262.     *++yyssp = yystate;
  263.     *++yyvsp = yyval;
  264.     goto yyloop;
  265. yyoverflow:
  266.     yyerror("yacc stack overflow");
  267. yyabort:
  268.     return (1);
  269. yyaccept:
  270.     return (0);
  271. }
  272.